ถอดรหัส Transformer: เจาะลึกการใช้งานกลไก Attention

ในปี 2017 โลกของปัญญาประดิษฐ์ (Artificial Intelligence) ได้เปลี่ยนแปลงไปอย่างสิ้นเชิงด้วยงานวิจัยเพียงชิ้นเดียวจาก Google Brain ที่มีชื่อว่า "Attention Is All You Need" งานวิจัยนี้ได้นำเสนอสถาปัตยกรรม Transformer ซึ่งเป็นการออกแบบใหม่ที่ละทิ้งเลเยอร์แบบ Recurrent และ Convolutional ที่เคยครอบงำงานที่อิงตามลำดับ (sequence-based tasks) เช่น การแปลภาษาด้วยเครื่องจักร (machine translation) ไปโดยสิ้นเชิง หัวใจสำคัญของการปฏิวัตินี้คือแนวคิดที่ทรงพลังแต่สง่างาม: กลไก Attention

ปัจจุบัน Transformers เป็นรากฐานของโมเดล AI ที่ล้ำสมัยเกือบทุกรูปแบบ ตั้งแต่โมเดลภาษาขนาดใหญ่ (large language models) เช่น GPT-4 และ LLaMA ไปจนถึงโมเดลที่ก้าวล้ำในด้าน Computer Vision และการค้นพบยา การทำความเข้าใจกลไก Attention ไม่ใช่ทางเลือกอีกต่อไปสำหรับผู้ปฏิบัติงานด้าน AI แต่เป็นสิ่งจำเป็น คู่มือฉบับสมบูรณ์นี้ออกแบบมาสำหรับนักพัฒนา นักวิทยาศาสตร์ข้อมูล และผู้ที่สนใจ AI ทั่วโลก เราจะทำให้กลไก Attention เป็นเรื่องง่าย โดยแบ่งย่อยจากหลักการพื้นฐานไปสู่การใช้งานจริงในโค้ด เป้าหมายของเราคือการมอบสัญชาตญาณและทักษะทางเทคนิคให้คุณเพื่อทำความเข้าใจและสร้างเครื่องยนต์ที่ขับเคลื่อน AI สมัยใหม่

Attention คืออะไร? สัญชาตญาณระดับโลก

ก่อนที่จะเจาะลึกลงไปในเมทริกซ์และสูตร มาสร้างสัญชาตญาณที่เป็นสากลกันก่อน ลองจินตนาการว่าคุณกำลังอ่านประโยคนี้: "เรือบรรทุกลำนี้ ซึ่งบรรทุกสินค้าจากท่าเรือระหว่างประเทศหลายแห่ง แล่นไปในทะเลอย่างราบรื่น"

เพื่อให้เข้าใจความหมายของคำว่า "แล่น" สมองของคุณไม่ได้ให้น้ำหนักเท่ากันกับคำอื่นๆ ทั้งหมดในประโยค สัญชาตญาณของคุณจะให้ความสนใจกับคำว่า "เรือ" และ "ทะเล" มากกว่าคำว่า "สินค้า" หรือ "ท่าเรือ" การเลือกโฟกัสนี้—ความสามารถในการชั่งน้ำหนักความสำคัญของข้อมูลที่แตกต่างกันแบบไดนามิกเมื่อประมวลผลองค์ประกอบใดองค์ประกอบหนึ่ง—คือแก่นแท้ของ Attention

ในบริบทของ AI กลไก Attention ช่วยให้โมเดลทำเช่นเดียวกันได้ เมื่อประมวลผลส่วนหนึ่งของลำดับอินพุต (เช่น คำในประโยค หรือส่วนย่อยในรูปภาพ) โมเดลสามารถดูที่ลำดับทั้งหมดและตัดสินใจว่าส่วนอื่นๆ ส่วนใดที่เกี่ยวข้องมากที่สุดสำหรับการทำความเข้าใจส่วนปัจจุบัน ความสามารถในการสร้างแบบจำลองการอ้างอิงระยะยาว (long-range dependencies) โดยตรง โดยไม่ต้องส่งข้อมูลตามลำดับผ่านสายโซ่แบบ Recurrent คือสิ่งที่ทำให้ Transformers ทรงพลังและมีประสิทธิภาพมาก

เครื่องยนต์หลัก: Scaled Dot-Product Attention

รูปแบบ Attention ที่ใช้กันทั่วไปใน Transformers เรียกว่า Scaled Dot-Product Attention สูตรอาจดูน่ากลัวในตอนแรก แต่สร้างขึ้นจากชุดขั้นตอนเชิงตรรกะที่สอดคล้องกับสัญชาตญาณของเราอย่างสวยงาม

สูตรคือ: Attention(Q, K, V) = softmax( (QK^T) / √d_k ) * V

มาแบ่งย่อยทีละส่วน โดยเริ่มจากอินพุตหลักสามรายการ

ไตรลักษณ์: Query, Key และ Value (Q, K, V)

ในการใช้งาน Attention เราจะแปลงข้อมูลอินพุตของเรา (เช่น Word Embedding) เป็นการแสดงแทนที่แตกต่างกันสามแบบ: Queries, Keys และ Values คิดว่านี่เป็นระบบการเรียกค้นข้อมูล เช่น การค้นหาข้อมูลในห้องสมุดดิจิทัล:

• Query (Q): นี่แสดงถึงรายการปัจจุบันที่คุณกำลังโฟกัสอยู่ นี่คือคำถามของคุณ สำหรับคำเฉพาะเจาะจง เวกเตอร์ Query จะถามว่า "ข้อมูลใดในส่วนที่เหลือของประโยคที่เกี่ยวข้องกับฉัน"
• Key (K): แต่ละรายการในลำดับมีเวกเตอร์ Key นี่เหมือนกับป้ายกำกับ ชื่อ หรือคำหลักสำหรับข้อมูลชิ้นหนึ่ง Query จะถูกเปรียบเทียบกับ Keys ทั้งหมดเพื่อค้นหารายการที่เกี่ยวข้องมากที่สุด
• Value (V): แต่ละรายการในลำดับยังมีเวกเตอร์ Value อีกด้วย นี่คือเนื้อหาหรือข้อมูลจริง เมื่อ Query พบ Keys ที่ตรงกันที่สุดแล้ว เราจะเรียก Values ที่เกี่ยวข้อง

ใน Self-Attention กลไกที่ใช้ภายในตัวเข้ารหัส (encoder) และตัวถอดรหัส (decoder) ของ Transformer นั้น Queries, Keys และ Values ทั้งหมดถูกสร้างขึ้นจากลำดับอินพุตเดียวกัน คำแต่ละคำในประโยคจะสร้างเวกเตอร์ Q, K และ V ของตัวเองโดยส่งผ่านเลเยอร์เชิงเส้น (linear layers) ที่เรียนรู้แล้วสามเลเยอร์ที่แยกจากกัน สิ่งนี้ช่วยให้โมเดลคำนวณ Attention ของทุกคำกับทุกคำอื่นในประโยคเดียวกันได้

การแบ่งย่อยการใช้งานทีละขั้นตอน

มาดูการดำเนินการของสูตร โดยเชื่อมโยงแต่ละขั้นตอนกับวัตถุประสงค์

ขั้นตอนที่ 1: คำนวณคะแนนความคล้ายคลึง (Q * K^T)

ขั้นตอนแรกคือการวัดว่าแต่ละ Query สอดคล้องกับแต่ละ Key มากน้อยเพียงใด เราทำได้โดยการหาผลคูณจุด (dot product) ของทุกเวกเตอร์ Query กับทุกเวกเตอร์ Key ในทางปฏิบัติ สิ่งนี้ทำได้อย่างมีประสิทธิภาพสำหรับทั้งลำดับโดยใช้การคูณเมทริกซ์เพียงครั้งเดียว: `Q` คูณด้วย Transpose ของ `K` (`K^T`)

• อินพุต: เมทริกซ์ Query `Q` ที่มีรูปร่าง `(sequence_length, d_q)` และเมทริกซ์ Key `K` ที่มีรูปร่าง `(sequence_length, d_k)` หมายเหตุ: `d_q` ต้องเท่ากับ `d_k`
• การดำเนินการ: `Q * K^T`
• เอาต์พุต: เมทริกซ์คะแนน Attention ที่มีรูปร่าง `(sequence_length, sequence_length)` องค์ประกอบที่ `(i, j)` ในเมทริกซ์นี้แสดงถึงคะแนนความคล้ายคลึงดิบระหว่างคำที่ `i` (ในฐานะ Query) และคำที่ `j` (ในฐานะ Key) คะแนนที่สูงกว่าหมายถึงความสัมพันธ์ที่แข็งแกร่งกว่า

ขั้นตอนที่ 2: สเกล ( / √d_k )

นี่คือขั้นตอนการรักษาเสถียรภาพที่สำคัญแต่เรียบง่าย ผู้เขียนบทความต้นฉบับพบว่าสำหรับค่ามากของมิติ Key `d_k` ผลคูณจุดสามารถเติบโตได้มาก เมื่อตัวเลขขนาดใหญ่นี้ถูกป้อนเข้าสู่ฟังก์ชัน Softmax (ขั้นตอนต่อไปของเรา) พวกเขาสามารถผลักดันมันเข้าไปในพื้นที่ที่ Gradient มีขนาดเล็กมาก ปรากฏการณ์นี้เรียกว่า Vanishing Gradients ซึ่งสามารถทำให้โมเดลฝึกยาก

เพื่อตอบโต้สิ่งนี้ เราจะปรับขนาดคะแนนลงโดยหารด้วยรากที่สองของมิติของเวกเตอร์ Key, √d_k สิ่งนี้จะทำให้ Variance ของคะแนนอยู่ที่ 1 ทำให้มั่นใจได้ถึง Gradients ที่เสถียรยิ่งขึ้นตลอดการฝึก

ขั้นตอนที่ 3: ใช้ Softmax (softmax(...))

ตอนนี้เรามีเมทริกซ์ของคะแนนการจัดตำแหน่งที่ปรับขนาดแล้ว แต่คะแนนเหล่านี้เป็นแบบสุ่ม เพื่อทำให้พวกเขาสามารถตีความและมีประโยชน์ได้ เราจะใช้ฟังก์ชัน Softmax ตามแต่ละแถว ฟังก์ชัน Softmax ทำสองสิ่ง:

1. แปลงคะแนนทั้งหมดเป็นตัวเลขบวก
2. ทำให้เป็นปกติเพื่อให้คะแนนในแต่ละแถวรวมกันเป็น 1

เอาต์พุตของขั้นตอนนี้คือเมทริกซ์ของ Attention Weights แต่ละแถวแสดงถึงการกระจายความน่าจะเป็น บอกเราว่าคำที่ตำแหน่งแถวนั้นควรให้ความสนใจกับคำอื่นๆ ทั้งหมดในลำดับมากน้อยเพียงใด น้ำหนัก 0.9 สำหรับคำว่า "เรือ" ในแถวสำหรับ "แล่น" หมายความว่าเมื่อคำนวณการแสดงแทนใหม่สำหรับ "แล่น" 90% ของข้อมูลจะมาจาก "เรือ"

ขั้นตอนที่ 4: คำนวณผลรวมถ่วงน้ำหนัก ( * V )

ขั้นตอนสุดท้ายคือการใช้น้ำหนัก Attention เหล่านี้เพื่อสร้างการแสดงแทนที่ตระหนักถึงบริบทใหม่สำหรับแต่ละคำ เราทำได้โดยการคูณเมทริกซ์น้ำหนัก Attention ด้วยเมทริกซ์ Value `V`

• อินพุต: เมทริกซ์น้ำหนัก Attention `(sequence_length, sequence_length)` และเมทริกซ์ Value `V` `(sequence_length, d_v)`
• การดำเนินการ: `weights * V`
• เอาต์พุต: เมทริกซ์เอาต์พุตสุดท้ายที่มีรูปร่าง `(sequence_length, d_v)`

สำหรับแต่ละคำ (แต่ละแถว) การแสดงแทนใหม่คือผลรวมถ่วงน้ำหนักของเวกเตอร์ Value ทั้งหมดในลำดับ คำที่มีน้ำหนัก Attention สูงกว่าจะมีส่วนร่วมในผลรวมนี้มากขึ้น ผลลัพธ์คือชุดของ Embeddings ที่เวกเตอร์ของแต่ละคำไม่ได้มีความหมายของมันเองเท่านั้น แต่เป็นการผสมผสานความหมายของมันและความหมายของคำที่มันให้ความสนใจ ตอนนี้มันอุดมไปด้วยบริบท

ตัวอย่างโค้ดเชิงปฏิบัติ: Scaled Dot-Product Attention ใน PyTorch

ทฤษฎีจะเข้าใจได้ดีที่สุดผ่านการปฏิบัติ นี่คือการใช้งานแบบมีคำอธิบายประกอบอย่างง่ายของกลไก Scaled Dot-Product Attention โดยใช้ Python และไลบรารี PyTorch ซึ่งเป็นเฟรมเวิร์กยอดนิยมสำหรับการเรียนรู้เชิงลึก

            
import torch
import torch.nn as nn
import math

class ScaledDotProductAttention(nn.Module):
    """ Implements the Scaled Dot-Product Attention mechanism. """
    def __init__(self):
        super(ScaledDotProductAttention, self).__init__()

    def forward(self, q, k, v, mask=None):
        # q, k, v must have the same dimension d_k = d_v = d_model / h
        # In practice, these tensors will also have a batch dimension and head dimension.
        # For clarity, let's assume shape [batch_size, num_heads, seq_len, d_k]
        
        d_k = k.size(-1)  # Get the dimension of the key vectors
        
        # 1. Calculate Similarity Scores: (Q * K^T)
        # Matmul for the last two dimensions: (seq_len, d_k) * (d_k, seq_len) -> (seq_len, seq_len)
        scores = torch.matmul(q, k.transpose(-2, -1))
        
        # 2. Scale the scores
        scaled_scores = scores / math.sqrt(d_k)
        
        # 3. (Optional) Apply mask to prevent attention to certain positions
        # The mask is crucial in the decoder to prevent attending to future tokens.
        if mask is not None:
            # Fills elements of self tensor with -1e9 where mask is True.
            scaled_scores = scaled_scores.masked_fill(mask == 0, -1e9)
        
        # 4. Apply Softmax to get attention weights
        # Softmax is applied on the last dimension (the keys) to get a distribution.
        attention_weights = torch.softmax(scaled_scores, dim=-1)
        
        # 5. Compute the Weighted Sum: (weights * V)
        # Matmul for the last two dimensions: (seq_len, seq_len) * (seq_len, d_v) -> (seq_len, d_v)
        output = torch.matmul(attention_weights, v)
        
        return output, attention_weights


            

              
                Copy
              
            
          

ยกระดับ: Multi-Head Attention

กลไก Scaled Dot-Product Attention ทรงพลัง แต่มีข้อจำกัด มันคำนวณชุดของ Attention Weights เพียงชุดเดียว บังคับให้มันเฉลี่ยโฟกัส กลไก Attention เดียวอาจเรียนรู้ที่จะโฟกัสที่ความสัมพันธ์ระหว่างประธานกับกริยา ตัวอย่างเช่น แต่ความสัมพันธ์อื่นๆ ล่ะ เช่น คำสรรพนาม-คำนามนำหน้า หรือความแตกต่างทางสไตล์?

นี่คือที่มาของ Multi-Head Attention แทนที่จะทำการคำนวณ Attention เพียงครั้งเดียว มันจะรันกลไก Attention หลายครั้งแบบขนานกันแล้วรวมผลลัพธ์

"ทำไม": การจับความสัมพันธ์ที่หลากหลาย

คิดว่าเป็นการมีคณะกรรมการผู้เชี่ยวชาญแทนที่จะเป็นผู้เชี่ยวชาญทั่วไปเพียงคนเดียว แต่ละ "หัว" ใน Multi-Head Attention สามารถคิดได้ว่าเป็นผู้เชี่ยวชาญที่เรียนรู้ที่จะโฟกัสที่ความสัมพันธ์หรือแง่มุมที่แตกต่างกันของข้อมูลอินพุต

สำหรับประโยค "สัตว์ตัวนั้นไม่ข้ามถนนเพราะมันเหนื่อยเกินไป"

• หัว 1 อาจเรียนรู้ที่จะเชื่อมโยงคำสรรพนาม "มัน" กลับไปยังคำนามนำหน้า "สัตว์"
• หัว 2 อาจเรียนรู้ความสัมพันธ์เชิงเหตุและผลระหว่าง "ไม่ข้าม" และ "เหนื่อย"
• หัว 3 อาจจับความสัมพันธ์ทางวากยสัมพันธ์ระหว่างกริยา "เป็น" และประธาน "มัน"

ด้วยการมีหลายหัว (บทความ Transformer ดั้งเดิมใช้ 8) โมเดลสามารถจับความสัมพันธ์ทางวากยสัมพันธ์และความหมายที่หลากหลายในข้อมูลได้พร้อมกัน นำไปสู่การแสดงแทนที่ละเอียดอ่อนและทรงพลังยิ่งขึ้น

"อย่างไร": แยก, ให้ความสนใจ, เชื่อมต่อ, ฉายภาพ

การใช้งาน Multi-Head Attention เป็นไปตามกระบวนการสี่ขั้นตอน:

1. การฉายภาพเชิงเส้น: Embeddings อินพุตจะถูกส่งผ่านเลเยอร์เชิงเส้นที่แยกจากกันสามเลเยอร์เพื่อสร้างเมทริกซ์ Query, Key และ Value เริ่มต้น จากนั้นสิ่งเหล่านี้จะถูกแบ่งออกเป็น `h` ชิ้นเล็กลง (หนึ่งชิ้นสำหรับแต่ละหัว) ตัวอย่างเช่น หากมิติโมเดล `d_model` ของคุณคือ 512 และคุณมี 8 หัว แต่ละหัวจะทำงานกับเวกเตอร์ Q, K และ V ที่มีมิติ 64 (512 / 8)
2. Attention แบบขนาน: กลไก Scaled Dot-Product Attention ที่เรากล่าวถึงก่อนหน้านี้ถูกนำไปใช้โดยอิสระและแบบขนานกับแต่ละชุดของปริภูมิย่อย Q, K และ V ทั้ง `h` ชุด สิ่งนี้นำไปสู่เมทริกซ์เอาต์พุต Attention ที่แยกจากกัน `h` ชุด
3. เชื่อมต่อ: เมทริกซ์เอาต์พุต `h` ถูกเชื่อมต่อกลับเข้าด้วยกันเป็นเมทริกซ์ขนาดใหญ่เพียงเมทริกซ์เดียว ในตัวอย่างของเรา เมทริกซ์ 8 ขนาด 64 จะถูกเชื่อมต่อเพื่อสร้างเมทริกซ์ขนาด 512 หนึ่งเมทริกซ์
4. การฉายภาพสุดท้าย: เมทริกซ์ที่เชื่อมต่อนี้ถูกส่งผ่านเลเยอร์เชิงเส้นสุดท้าย เลเยอร์นี้ช่วยให้โมเดลเรียนรู้วิธีรวมข้อมูลที่เรียนรู้โดยหัวที่แตกต่างกันให้ดีที่สุด สร้างเอาต์พุตสุดท้ายที่เป็นเอกภาพ

การใช้งานโค้ด: Multi-Head Attention ใน PyTorch

สร้างจากโค้ดก่อนหน้าของเรา นี่คือการใช้งานมาตรฐานของบล็อก Multi-Head Attention

            
class MultiHeadAttention(nn.Module):
    """ Implements the Multi-Head Attention mechanism. """
    def __init__(self, d_model, num_heads):
        super(MultiHeadAttention, self).__init__()
        assert d_model % num_heads == 0, "d_model must be divisible by num_heads"
        
        self.d_model = d_model
        self.num_heads = num_heads
        self.d_k = d_model // num_heads
        
        # Linear layers for Q, K, V and the final output
        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)
        
        self.attention = ScaledDotProductAttention()

    def forward(self, q, k, v, mask=None):
        batch_size = q.size(0)
        
        # 1. Apply linear projections
        q, k, v = self.W_q(q), self.W_k(k), self.W_v(v)
        
        # 2. Reshape for multi-head attention
        # (batch_size, seq_len, d_model) -> (batch_size, num_heads, seq_len, d_k)
        q = q.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        k = k.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        v = v.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        
        # 3. Apply attention on all heads in parallel
        context, _ = self.attention(q, k, v, mask=mask)
        
        # 4. Concatenate heads and apply final linear layer
        # (batch_size, num_heads, seq_len, d_k) -> (batch_size, seq_len, num_heads, d_k)
        context = context.transpose(1, 2).contiguous()
        # (batch_size, seq_len, num_heads, d_k) -> (batch_size, seq_len, d_model)
        context = context.view(batch_size, -1, self.d_model)
        
        output = self.W_o(context)
        
        return output


            

              
                Copy
              
            
          

ผลกระทบระดับโลก: ทำไมกลไกนี้ถึงเป็นการเปลี่ยนแปลงเกม

หลักการของ Attention ไม่ได้จำกัดอยู่แค่การประมวลผลภาษาธรรมชาติ กลไกนี้ได้รับการพิสูจน์แล้วว่าเป็นเครื่องมือที่ใช้งานได้หลากหลายและทรงพลังในหลายโดเมน ขับเคลื่อนความก้าวหน้าในระดับโลก

• การทำลายกำแพงภาษา: ในการแปลภาษาด้วยเครื่องจักร Attention ช่วยให้โมเดลสร้างการจัดตำแหน่งที่ไม่เป็นเชิงเส้นโดยตรงระหว่างคำในภาษาต่างๆ ตัวอย่างเช่น สามารถจับคู่วลีภาษาฝรั่งเศส "la voiture bleue" กับภาษาอังกฤษ "the blue car" ได้อย่างถูกต้อง จัดการตำแหน่งคำคุณศัพท์ที่แตกต่างกันอย่างสวยงาม
• ขับเคลื่อนการค้นหาและการสรุป: สำหรับงานต่างๆ เช่น การสรุปเอกสารขนาดยาวหรือตอบคำถามเกี่ยวกับเอกสารนั้น Self-Attention ช่วยให้โมเดลระบุประโยคและแนวคิดที่โดดเด่นที่สุดโดยทำความเข้าใจเว็บที่ซับซ้อนของความสัมพันธ์ระหว่างพวกเขา
• การพัฒนาวิทยาศาสตร์และการแพทย์: นอกเหนือจากข้อความแล้ว Attention ยังใช้เพื่อสร้างแบบจำลองการโต้ตอบที่ซับซ้อนในข้อมูลทางวิทยาศาสตร์ ในจีโนมิกส์ (genomics) สามารถสร้างแบบจำลองการพึ่งพากันระหว่างคู่เบสที่อยู่ห่างไกลในสาย DNA ในการค้นพบยา ช่วยทำนายปฏิสัมพันธ์ระหว่างโปรตีน เร่งการวิจัยเกี่ยวกับการรักษาใหม่ๆ
• การปฏิวัติ Computer Vision: ด้วยการถือกำเนิดของ Vision Transformers (ViT) กลไก Attention จึงเป็นเสาหลักของ Computer Vision สมัยใหม่ ด้วยการปฏิบัติต่อภาพเป็นลำดับของส่วนย่อย Self-Attention ช่วยให้โมเดลเข้าใจความสัมพันธ์ระหว่างส่วนต่างๆ ของภาพ นำไปสู่ประสิทธิภาพที่ล้ำสมัยในการจำแนกประเภทรูปภาพและการตรวจจับวัตถุ

สรุป: อนาคตคือการใส่ใจ

การเดินทางจากแนวคิดที่ใช้งานง่ายของการโฟกัสไปสู่การใช้งานจริงของ Multi-Head Attention เผยให้เห็นกลไกที่ทรงพลังและมีเหตุผลอย่างลึกซึ้ง มันทำให้โมเดล AI สามารถประมวลผลข้อมูลได้ ไม่ใช่ในฐานะลำดับที่แข็งแกร่ง แต่เป็นเครือข่ายความสัมพันธ์ที่ยืดหยุ่นและเชื่อมต่อถึงกัน การเปลี่ยนแปลงมุมมองนี้ ซึ่งนำเสนอโดยสถาปัตยกรรม Transformer ได้ปลดล็อกความสามารถที่ไม่เคยมีมาก่อนใน AI

ด้วยการทำความเข้าใจวิธีใช้งานและตีความกลไก Attention คุณกำลังเข้าใจส่วนประกอบพื้นฐานของ AI สมัยใหม่ ในขณะที่การวิจัยยังคงพัฒนาต่อไป รูปแบบ Attention ใหม่และมีประสิทธิภาพมากขึ้นจะเกิดขึ้นอย่างไม่ต้องสงสัย แต่หลักการสำคัญ—ของการเลือกโฟกัสเฉพาะสิ่งที่สำคัญที่สุด—จะยังคงเป็นธีมหลักในการแสวงหาอย่างต่อเนื่องสำหรับระบบที่ชาญฉลาดและมีความสามารถมากขึ้น